{
	"info": {
		"_postman_id": "0ea8945a-2cd7-484f-8ffd-13eb0d94a6cd",
		"name": "QRKot",
		"schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
		"_exporter_id": "16131548"
	},
	"item": [
		{
			"name": "auth",
			"item": [
				{
					"name": "create_users // No Auth",
					"item": [
						{
							"name": "create_first_user",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\":{",
											"        \"id\": {\"type\": \"number\"},",
											"        \"email\": {\"type\": \"string\"},",
											"        \"is_active\": {\"type\": \"boolean\"},",
											"        \"is_superuser\": {\"type\": \"boolean\"},",
											"        \"is_verified\": {\"type\": \"boolean\"}",
											"    },",
											"    \"required\": [\"id\", \"email\", \"is_active\", \"is_superuser\", \"is_verified\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 201\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Если запроc на регистрацию нового пользователя содержит корректные данные - должен вернуться ответ со статус-кодом 201\"",
											"    ).to.be.eql(\"Created\");",
											"    const userId = _.get(responseData, \"id\");",
											"    if (userId) {",
											"        pm.collectionVariables.set(\"firstUserId\", userId);",
											"    }",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"email\": \"{{firstUserEmail}}\",\n    \"password\": \"{{firstUserPassword}}\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/auth/register",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"auth",
										"register"
									]
								}
							},
							"response": []
						},
						{
							"name": "create_second_user",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\":{",
											"        \"id\": {\"type\": \"number\"},",
											"        \"email\": {\"type\": \"string\"},",
											"        \"is_active\": {\"type\": \"boolean\"},",
											"        \"is_superuser\": {\"type\": \"boolean\"},",
											"        \"is_verified\": {\"type\": \"boolean\"}",
											"    },",
											"    \"required\": [\"id\", \"email\", \"is_active\", \"is_superuser\", \"is_verified\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 201\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Если запроc на регистрацию нового пользователя содержит корректные данные - должен вернуться ответ со статус-кодом 201\"",
											"    ).to.be.eql(\"Created\");",
											"    const userId = _.get(responseData, \"id\");",
											"    if (userId) {",
											"        pm.collectionVariables.set(\"secondUserId\", userId);",
											"    }",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"email\": \"{{secondUserEmail}}\",\n    \"password\": \"{{secondUserPassword}}\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/auth/register",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"auth",
										"register"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "login // No Auth",
					"item": [
						{
							"name": "loging_first_user",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\":{",
											"        \"access_token\": {\"type\": \"string\"},",
											"        \"token_type\": {\"type\": \"string\"}",
											"    },",
											"    \"required\": [\"access_token\", \"token_type\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Если запроc на получение токена содержит корректные данные - должен вернуться ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const token = _.get(responseData, \"access_token\");",
											"    if (token) {",
											"        pm.collectionVariables.set(\"firstUserToken\", token);",
											"    }",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test('Тип токена должен быть `bearer`', function () {",
											"    pm.expect(",
											"        responseData['token_type'] === \"bearer\",",
											"        \"Убедитесь, что для токена используется транспорт Bearer\"",
											"    ).to.be.true",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "urlencoded",
									"urlencoded": [
										{
											"key": "username",
											"value": "{{firstUserEmail}}",
											"type": "text"
										},
										{
											"key": "password",
											"value": "{{firstUserPassword}}",
											"type": "text"
										}
									]
								},
								"url": {
									"raw": "{{baseURL}}/auth/jwt/login",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"auth",
										"jwt",
										"login"
									]
								}
							},
							"response": []
						},
						{
							"name": "loging_second_user",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\":{",
											"        \"access_token\": {\"type\": \"string\"},",
											"        \"token_type\": {\"type\": \"string\"}",
											"    },",
											"    \"required\": [\"access_token\", \"token_type\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Если запроc на получение токена содержит корректные данные - должен вернуться ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const token = _.get(responseData, \"access_token\");",
											"    if (token) {",
											"        pm.collectionVariables.set(\"secondUserToken\", token);",
											"    }",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test('Тип токена должен быть `bearer`', function () {",
											"    pm.expect(",
											"        responseData['token_type'] === \"bearer\",",
											"        \"Убедитесь, что для токена используется транспорт Bearer\"",
											"    ).to.be.true",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "urlencoded",
									"urlencoded": [
										{
											"key": "username",
											"value": "{{secondUserEmail}}",
											"type": "text"
										},
										{
											"key": "password",
											"value": "{{secondUserPassword}}",
											"type": "text"
										}
									]
								},
								"url": {
									"raw": "{{baseURL}}/auth/jwt/login",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"auth",
										"jwt",
										"login"
									]
								}
							},
							"response": []
						},
						{
							"name": "login_superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\":{",
											"        \"access_token\": {\"type\": \"string\"},",
											"        \"token_type\": {\"type\": \"string\"}",
											"    },",
											"    \"required\": [\"access_token\", \"token_type\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Если запроc на получение токена содержит корректные данные - должен вернуться ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const token = _.get(responseData, \"access_token\");",
											"    if (token) {",
											"        pm.collectionVariables.set(\"superuserToken\", token);",
											"    }",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test('Тип токена должен быть `bearer`', function () {",
											"    pm.expect(",
											"        responseData['token_type'] === \"bearer\",",
											"        \"Убедитесь, что для токена используется транспорт Bearer\"",
											"    ).to.be.true",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "urlencoded",
									"urlencoded": [
										{
											"key": "username",
											"value": "{{superuserEmail}}",
											"type": "text"
										},
										{
											"key": "password",
											"value": "{{superuserPassword}}",
											"type": "text"
										}
									]
								},
								"url": {
									"raw": "{{baseURL}}/auth/jwt/login",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"auth",
										"jwt",
										"login"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "logout",
					"item": [
						{
							"name": "logout_first_user // First User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc пользователя на выход из системы возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{firstUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/auth/jwt/logout",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"auth",
										"jwt",
										"logout"
									]
								}
							},
							"response": []
						},
						{
							"name": "loging_first_user // No Auth",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\":{",
											"        \"access_token\": {\"type\": \"string\"},",
											"        \"token_type\": {\"type\": \"string\"}",
											"    },",
											"    \"required\": [\"access_token\", \"token_type\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Если запроc на получение токена содержит корректные данные - должен вернуться ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const token = _.get(responseData, \"access_token\");",
											"    if (token) {",
											"        pm.collectionVariables.set(\"firstUserToken\", token);",
											"    }",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test('Тип токена должен быть `bearer`', function () {",
											"    pm.expect(",
											"        responseData['token_type'] === \"bearer\",",
											"        \"Убедитесь, что для токена используется транспорт Bearer\"",
											"    ).to.be.true",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "urlencoded",
									"urlencoded": [
										{
											"key": "username",
											"value": "{{firstUserEmail}}",
											"type": "text"
										},
										{
											"key": "password",
											"value": "{{firstUserPassword}}",
											"type": "text"
										}
									]
								},
								"url": {
									"raw": "{{baseURL}}/auth/jwt/login",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"auth",
										"jwt",
										"login"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "bad_requests",
					"item": [
						{
							"name": "registration_bad_requests // No Auth",
							"item": [
								{
									"name": "create_user_with_email_in_use",
									"event": [
										{
											"listen": "test",
											"script": {
												"exec": [
													"const responseData = pm.response.json();",
													"const responseSchema = {",
													"    \"type\": \"object\",",
													"    \"properties\":{",
													"        \"detail\": {\"type\": \"string\"},",
													"    },",
													"    \"required\": [\"detail\"],",
													"    \"additionalProperties\": false",
													"};",
													"",
													"pm.test(\"Статус-код ответа должен быть 400\", function () {",
													"    pm.expect(",
													"        pm.response.status,",
													"        \"Если запроc на регистрацию нового пользователя содержит email уже зарегистрированного пользователя - должен вернуться ответ со статус-кодом 400\"",
													"    ).to.be.eql(\"Bad Request\");",
													"});",
													"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
													"    pm.response.to.have.jsonSchema(responseSchema);",
													"    pm.expect(",
													"        responseData[\"detail\"] === \"REGISTER_USER_ALREADY_EXISTS\",",
													"        \"Ключ `delail` в ответе должен содержать строку `REGISTER_USER_ALREADY_EXISTS`\"",
													"    ).to.be.true",
													"});",
													""
												],
												"type": "text/javascript"
											}
										}
									],
									"request": {
										"method": "POST",
										"header": [],
										"body": {
											"mode": "raw",
											"raw": "{\n    \"email\": \"{{firstUserEmail}}\",\n    \"password\": \"{{firstUserPassword}}\"\n}",
											"options": {
												"raw": {
													"language": "json"
												}
											}
										},
										"url": {
											"raw": "{{baseURL}}/auth/register",
											"host": [
												"{{baseURL}}"
											],
											"path": [
												"auth",
												"register"
											]
										}
									},
									"response": []
								},
								{
									"name": "create_user_without_password_field",
									"event": [
										{
											"listen": "test",
											"script": {
												"exec": [
													"const responseSchema = {",
													"    \"type\": \"object\",",
													"    \"properties\": {",
													"        \"detail\": {",
													"            \"type\": \"array\",",
													"            \"items\": {",
													"                \"type\": \"object\",",
													"                \"properties\": {",
													"                    \"loc\": {",
													"                        \"type\": \"array\",",
													"                        \"items\": {",
													"                            \"type\": \"string\"",
													"                        }",
													"                    },",
													"                    \"msg\": {",
													"                        \"type\": \"string\"",
													"                    },",
													"                    \"type\": {",
													"                        \"type\": \"string\"",
													"                    }",
													"                },",
													"                \"required\": [\"loc\", \"msg\", \"type\"],",
													"                \"additionalProperties\": false",
													"            }",
													"        }",
													"    },",
													"    \"required\": [\"detail\"],",
													"    \"additionalProperties\": false",
													"};",
													"",
													"pm.test(\"Статус-код ответа должен быть 422\", function () {",
													"    pm.expect(",
													"        pm.response.status,",
													"        \"Если в запроcе на регистрацию нового пользователя нет поля `password` - должен вернуться ответ со статус-кодом 422\"",
													"    ).to.be.eql(\"Unprocessable Entity\");",
													"});",
													"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
													"    pm.response.to.have.jsonSchema(responseSchema);",
													"});",
													""
												],
												"type": "text/javascript"
											}
										}
									],
									"request": {
										"method": "POST",
										"header": [],
										"body": {
											"mode": "raw",
											"raw": "{\n    \"email\": \"nopassword@user.ru\"\n}",
											"options": {
												"raw": {
													"language": "json"
												}
											}
										},
										"url": {
											"raw": "{{baseURL}}/auth/register",
											"host": [
												"{{baseURL}}"
											],
											"path": [
												"auth",
												"register"
											]
										}
									},
									"response": []
								},
								{
									"name": "create_user_with_empty_password_field",
									"event": [
										{
											"listen": "test",
											"script": {
												"exec": [
													"const responseSchema = {",
													"    \"type\": \"object\",",
													"    \"properties\": {",
													"        \"detail\": {",
													"            \"type\": \"object\",",
													"            \"properties\": {",
													"                \"code\": {",
													"                    \"type\": \"string\"",
													"                },",
													"                \"reason\": {",
													"                    \"type\": \"string\"",
													"                }",
													"            },",
													"            \"required\": [\"code\", \"reason\"],",
													"            \"additionalProperties\": false",
													"        }",
													"    },",
													"    \"required\": [\"detail\"],",
													"    \"additionalProperties\": false",
													"};",
													"",
													"pm.test(\"Статус-код ответа должен быть 400\", function () {",
													"    pm.expect(",
													"        pm.response.status,",
													"        \"Убедитесь, что запроc на регистрацию нового пользователя с пустым полем `password` возвращает ответ со статус-кодом 400\"",
													"    ).to.be.eql(\"Bad Request\");",
													"});",
													"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
													"    pm.response.to.have.jsonSchema(responseSchema);",
													"});",
													""
												],
												"type": "text/javascript"
											}
										}
									],
									"request": {
										"method": "POST",
										"header": [],
										"body": {
											"mode": "raw",
											"raw": "{\n    \"email\": \"emptypassword@user.ru\",\n    \"password\": \"\"\n}",
											"options": {
												"raw": {
													"language": "json"
												}
											}
										},
										"url": {
											"raw": "{{baseURL}}/auth/register",
											"host": [
												"{{baseURL}}"
											],
											"path": [
												"auth",
												"register"
											]
										}
									},
									"response": []
								},
								{
									"name": "create_user_without_email_field",
									"event": [
										{
											"listen": "test",
											"script": {
												"exec": [
													"const responseSchema = {",
													"    \"type\": \"object\",",
													"    \"properties\": {",
													"        \"detail\": {",
													"            \"type\": \"array\",",
													"            \"items\": {",
													"                \"type\": \"object\",",
													"                \"properties\": {",
													"                    \"loc\": {",
													"                        \"type\": \"array\",",
													"                        \"items\": {",
													"                            \"type\": \"string\"",
													"                        }",
													"                    },",
													"                    \"msg\": {",
													"                        \"type\": \"string\"",
													"                    },",
													"                    \"type\": {",
													"                        \"type\": \"string\"",
													"                    }",
													"                },",
													"                \"required\": [\"loc\", \"msg\", \"type\"],",
													"                \"additionalProperties\": false",
													"            }",
													"        }",
													"    },",
													"    \"required\": [\"detail\"],",
													"    \"additionalProperties\": false",
													"};",
													"",
													"pm.test(\"Статус-код ответа должен быть 422\", function () {",
													"    pm.expect(",
													"        pm.response.status,",
													"        \"Убедитесь, что запроc на регистрацию нового пользователя без указания поля `username` возвращает ответ со статус-кодом 422\"",
													"    ).to.be.eql(\"Unprocessable Entity\");",
													"});",
													"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
													"    pm.response.to.have.jsonSchema(responseSchema);",
													"});",
													""
												],
												"type": "text/javascript"
											}
										}
									],
									"request": {
										"method": "POST",
										"header": [],
										"body": {
											"mode": "raw",
											"raw": "{\n    \"password\": \"{{firstUserPassword}}\"\n}",
											"options": {
												"raw": {
													"language": "json"
												}
											}
										},
										"url": {
											"raw": "{{baseURL}}/auth/register",
											"host": [
												"{{baseURL}}"
											],
											"path": [
												"auth",
												"register"
											]
										}
									},
									"response": []
								},
								{
									"name": "create_user_with_empty_email_field",
									"event": [
										{
											"listen": "test",
											"script": {
												"exec": [
													"const responseSchema = {",
													"    \"type\": \"object\",",
													"    \"properties\": {",
													"        \"detail\": {",
													"            \"type\": \"array\",",
													"            \"items\": {",
													"                \"type\": \"object\",",
													"                \"properties\": {",
													"                    \"loc\": {",
													"                        \"type\": \"array\",",
													"                        \"items\": {",
													"                            \"type\": \"string\"",
													"                        }",
													"                    },",
													"                    \"msg\": {",
													"                        \"type\": \"string\"",
													"                    },",
													"                    \"type\": {",
													"                        \"type\": \"string\"",
													"                    }",
													"                },",
													"                \"required\": [\"loc\", \"msg\", \"type\"],",
													"                \"additionalProperties\": false",
													"            }",
													"        }",
													"    },",
													"    \"required\": [\"detail\"],",
													"    \"additionalProperties\": false",
													"};",
													"",
													"pm.test(\"Статус-код ответа должен быть 422\", function () {",
													"    pm.expect(",
													"        pm.response.status,",
													"        \"Убедитесь, что запроc на регистрацию нового пользователя без указания поля `username` возвращает ответ со статус-кодом 422\"",
													"    ).to.be.eql(\"Unprocessable Entity\");",
													"});",
													"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
													"    pm.response.to.have.jsonSchema(responseSchema);",
													"});",
													""
												],
												"type": "text/javascript"
											}
										}
									],
									"request": {
										"method": "POST",
										"header": [],
										"body": {
											"mode": "raw",
											"raw": "{\n    \"email\": \"\",\n    \"password\": \"{{firstUserPassword}}\"\n}",
											"options": {
												"raw": {
													"language": "json"
												}
											}
										},
										"url": {
											"raw": "{{baseURL}}/auth/register",
											"host": [
												"{{baseURL}}"
											],
											"path": [
												"auth",
												"register"
											]
										}
									},
									"response": []
								}
							]
						},
						{
							"name": "login_bad_requests // No Auth",
							"item": [
								{
									"name": "loging_with_bad_password",
									"event": [
										{
											"listen": "test",
											"script": {
												"exec": [
													"const responseSchema = {",
													"    \"type\": \"object\",",
													"    \"properties\":{",
													"        \"detail\": {\"type\": \"string\"},",
													"    },",
													"    \"required\": [\"detail\"],",
													"    \"additionalProperties\": false",
													"};",
													"",
													"pm.test(\"Статус-код ответа должен быть 400\", function () {",
													"    pm.expect(",
													"        pm.response.status,",
													"        \"Убедитесь, что если в запроcе на получение токена указан некорректный пароль - вернётся ответ со статус-кодом 400\"",
													"    ).to.be.eql(\"Bad Request\");",
													"});",
													"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
													"    pm.response.to.have.jsonSchema(responseSchema);",
													"});",
													""
												],
												"type": "text/javascript"
											}
										}
									],
									"request": {
										"method": "POST",
										"header": [],
										"body": {
											"mode": "urlencoded",
											"urlencoded": [
												{
													"key": "username",
													"value": "{{firstUserEmail}}",
													"type": "text"
												},
												{
													"key": "password",
													"value": "wrongPass",
													"type": "text"
												}
											]
										},
										"url": {
											"raw": "{{baseURL}}/auth/jwt/login",
											"host": [
												"{{baseURL}}"
											],
											"path": [
												"auth",
												"jwt",
												"login"
											]
										}
									},
									"response": []
								},
								{
									"name": "loging_without_password",
									"event": [
										{
											"listen": "test",
											"script": {
												"exec": [
													"const responseSchema = {",
													"    \"type\": \"object\",",
													"    \"properties\": {",
													"        \"detail\": {",
													"            \"type\": \"array\",",
													"            \"items\": {",
													"                \"type\": \"object\",",
													"                \"properties\": {",
													"                    \"loc\": {",
													"                        \"type\": \"array\",",
													"                        \"items\": {",
													"                            \"type\": \"string\"",
													"                        }",
													"                    },",
													"                    \"msg\": {",
													"                        \"type\": \"string\"",
													"                    },",
													"                    \"type\": {",
													"                        \"type\": \"string\"",
													"                    }",
													"                },",
													"                \"required\": [\"loc\", \"msg\", \"type\"],",
													"                \"additionalProperties\": false",
													"            }",
													"        }",
													"    },",
													"    \"required\": [\"detail\"],",
													"    \"additionalProperties\": false",
													"};",
													"",
													"pm.test(\"Статус-код ответа должен быть 422\", function () {",
													"    pm.expect(",
													"        pm.response.status,",
													"        \"Убедитесь, что если в запроcе на получение токена нет поля `password` - вернётся ответ со статус-кодом 422\"",
													"    ).to.be.eql(\"Unprocessable Entity\");",
													"});",
													"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
													"    pm.response.to.have.jsonSchema(responseSchema);",
													"});",
													""
												],
												"type": "text/javascript"
											}
										}
									],
									"request": {
										"method": "POST",
										"header": [],
										"body": {
											"mode": "urlencoded",
											"urlencoded": [
												{
													"key": "username",
													"value": "{{firstUserEmail}}",
													"type": "text"
												}
											]
										},
										"url": {
											"raw": "{{baseURL}}/auth/jwt/login",
											"host": [
												"{{baseURL}}"
											],
											"path": [
												"auth",
												"jwt",
												"login"
											]
										}
									},
									"response": []
								},
								{
									"name": "loging_without_username",
									"event": [
										{
											"listen": "test",
											"script": {
												"exec": [
													"const responseSchema = {",
													"    \"type\": \"object\",",
													"    \"properties\": {",
													"        \"detail\": {",
													"            \"type\": \"array\",",
													"            \"items\": {",
													"                \"type\": \"object\",",
													"                \"properties\": {",
													"                    \"loc\": {",
													"                        \"type\": \"array\",",
													"                        \"items\": {",
													"                            \"type\": \"string\"",
													"                        }",
													"                    },",
													"                    \"msg\": {",
													"                        \"type\": \"string\"",
													"                    },",
													"                    \"type\": {",
													"                        \"type\": \"string\"",
													"                    }",
													"                },",
													"                \"required\": [\"loc\", \"msg\", \"type\"],",
													"                \"additionalProperties\": false",
													"            }",
													"        }",
													"    },",
													"    \"required\": [\"detail\"],",
													"    \"additionalProperties\": false",
													"};",
													"",
													"pm.test(\"Статус-код ответа должен быть 422\", function () {",
													"    pm.expect(",
													"        pm.response.status,",
													"        \"Убедитесь, что если в запроcе на получение токена нет поля `username` - вернётся ответ со статус-кодом 422\"",
													"    ).to.be.eql(\"Unprocessable Entity\");",
													"});",
													"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
													"    pm.response.to.have.jsonSchema(responseSchema);",
													"});",
													""
												],
												"type": "text/javascript"
											}
										}
									],
									"request": {
										"method": "POST",
										"header": [],
										"body": {
											"mode": "urlencoded",
											"urlencoded": [
												{
													"key": "password",
													"value": "{{firstUserPassword}}",
													"type": "text"
												}
											]
										},
										"url": {
											"raw": "{{baseURL}}/auth/jwt/login",
											"host": [
												"{{baseURL}}"
											],
											"path": [
												"auth",
												"jwt",
												"login"
											]
										}
									},
									"response": []
								},
								{
									"name": "loging_with_bad_username",
									"event": [
										{
											"listen": "test",
											"script": {
												"exec": [
													"const responseSchema = {",
													"    \"type\": \"object\",",
													"    \"properties\":{",
													"        \"detail\": {\"type\": \"string\"},",
													"    },",
													"    \"required\": [\"detail\"],",
													"    \"additionalProperties\": false",
													"};",
													"",
													"pm.test(\"Статус-код ответа должен быть 400\", function () {",
													"    pm.expect(",
													"        pm.response.status,",
													"        \"Убедитесь, что если в запроcе на получение токена передан несуществующий `username` - вернётся ответ со статус-кодом 400\"",
													"    ).to.be.eql(\"Bad Request\");",
													"});",
													"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
													"    pm.response.to.have.jsonSchema(responseSchema);",
													"});",
													""
												],
												"type": "text/javascript"
											}
										}
									],
									"request": {
										"method": "POST",
										"header": [],
										"body": {
											"mode": "urlencoded",
											"urlencoded": [
												{
													"key": "username",
													"value": "this-user_doesnt-exists@user.ru",
													"type": "text"
												},
												{
													"key": "password",
													"value": "{{firstUserPassword}}",
													"type": "text"
												}
											]
										},
										"url": {
											"raw": "{{baseURL}}/auth/jwt/login",
											"host": [
												"{{baseURL}}"
											],
											"path": [
												"auth",
												"jwt",
												"login"
											]
										}
									},
									"response": []
								}
							]
						},
						{
							"name": "logout_bad_requests",
							"item": [
								{
									"name": "logout_without_token",
									"event": [
										{
											"listen": "test",
											"script": {
												"exec": [
													"const responseSchema = {",
													"    \"type\": \"object\",",
													"    \"properties\":{",
													"        \"detail\": {\"type\": \"string\"},",
													"    },",
													"    \"required\": [\"detail\"],",
													"    \"additionalProperties\": false",
													"};",
													"",
													"pm.test(\"Статус-код ответа должен быть 401\", function () {",
													"    pm.expect(",
													"        pm.response.status,",
													"        \"Убедитесь, что запроc пользователя на выход из системы без токена аутентификации возвращает ответ со статус-кодом 401\"",
													"    ).to.be.eql(\"Unauthorized\");",
													"});",
													"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
													"    pm.response.to.have.jsonSchema(responseSchema);",
													"});",
													""
												],
												"type": "text/javascript"
											}
										}
									],
									"request": {
										"auth": {
											"type": "noauth"
										},
										"method": "POST",
										"header": [],
										"url": {
											"raw": "{{baseURL}}/auth/jwt/logout",
											"host": [
												"{{baseURL}}"
											],
											"path": [
												"auth",
												"jwt",
												"logout"
											]
										}
									},
									"response": []
								},
								{
									"name": "logout_with_bad_token",
									"event": [
										{
											"listen": "test",
											"script": {
												"exec": [
													"const responseSchema = {",
													"    \"type\": \"object\",",
													"    \"properties\":{",
													"        \"detail\": {\"type\": \"string\"},",
													"    },",
													"    \"required\": [\"detail\"],",
													"    \"additionalProperties\": false",
													"};",
													"",
													"pm.test(\"Статус-код ответа должен быть 401\", function () {",
													"    pm.expect(",
													"        pm.response.status,",
													"        \"Убедитесь, что запроc пользователя на выход из системы с некорректным токеном аутентификации возвращает ответ со статус-кодом 401\"",
													"    ).to.be.eql(\"Unauthorized\");",
													"});",
													"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
													"    pm.response.to.have.jsonSchema(responseSchema);",
													"});",
													""
												],
												"type": "text/javascript"
											}
										}
									],
									"request": {
										"auth": {
											"type": "bearer",
											"bearer": [
												{
													"key": "token",
													"value": "wrong-tokenForUser",
													"type": "string"
												}
											]
										},
										"method": "POST",
										"header": [],
										"url": {
											"raw": "{{baseURL}}/auth/jwt/logout",
											"host": [
												"{{baseURL}}"
											],
											"path": [
												"auth",
												"jwt",
												"logout"
											]
										}
									},
									"response": []
								}
							]
						}
					]
				}
			]
		},
		{
			"name": "users",
			"item": [
				{
					"name": "get_users_me",
					"item": [
						{
							"name": "get_users_me // First User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"id\": {",
											"            \"type\": \"integer\"",
											"        },",
											"        \"email\": {",
											"            \"type\": \"string\",",
											"            \"format\": \"email\"",
											"        },",
											"        \"is_active\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"is_superuser\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"is_verified\": {",
											"            \"type\": \"boolean\"",
											"        }",
											"    },",
											"    \"required\": [\"id\", \"email\", \"is_active\", \"is_superuser\", \"is_verified\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc зарегистрированного пользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test(\"Данные из ответа должны совпадать с данными пользователя, присвоенными при его создании\", function () {",
											"    let firstUserId = pm.collectionVariables.get(\"firstUserId\");",
											"    let firstUserEmail = pm.collectionVariables.get(\"firstUserEmail\");",
											"    const responseData = pm.response.json();",
											"    pm.expect(",
											"        responseData.id,",
											"        \"Значение поля `id` в ответе на запрос не соответствует идентификатору, присвоенному пользователю при его создании\"",
											"    ).to.eql(firstUserId);",
											"    pm.expect(",
											"        responseData.email,",
											"        \"Значение поля `email` в ответе на запрос не соответствует значению, указанному при регистрации пользователя\"",
											"    ).to.eql(firstUserEmail);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{firstUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "GET",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/users/me",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"me"
									]
								}
							},
							"response": []
						},
						{
							"name": "get_users_me // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"id\": {",
											"            \"type\": \"integer\"",
											"        },",
											"        \"email\": {",
											"            \"type\": \"string\",",
											"            \"format\": \"email\"",
											"        },",
											"        \"is_active\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"is_superuser\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"is_verified\": {",
											"            \"type\": \"boolean\"",
											"        }",
											"    },",
											"    \"required\": [\"id\", \"email\", \"is_active\", \"is_superuser\", \"is_verified\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test(\"Данные из ответа должны совпадать с данными пользователя, присвоенными при его создании\", function () {",
											"    let superuserEmail = pm.collectionVariables.get(\"superuserEmail\");",
											"    const responseData = pm.response.json();",
											"    pm.expect(",
											"        responseData.email,",
											"        \"Значение поля `email` не соответствует значению, указанному при создании пользователя\"",
											"    ).to.eql(superuserEmail);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "GET",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/users/me",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"me"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "patch_users_me",
					"item": [
						{
							"name": "patch_user_me // First User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"id\": {",
											"            \"type\": \"integer\"",
											"        },",
											"        \"email\": {",
											"            \"type\": \"string\",",
											"            \"format\": \"email\"",
											"        },",
											"        \"is_active\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"is_superuser\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"is_verified\": {",
											"            \"type\": \"boolean\"",
											"        }",
											"    },",
											"    \"required\": [\"id\", \"email\", \"is_active\", \"is_superuser\", \"is_verified\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что корректный запроc зарегистрированного пользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const email = _.get(responseData, \"email\");",
											"    if (email) {",
											"        pm.collectionVariables.set(\"firstUserEmail\", email);",
											"    }",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test(\"Значение поля `email` должно обновиться\", function () {",
											"    const requestEmail = JSON.parse(pm.request.body.raw).email;",
											"    const responseEmail = responseData.email;",
											"    pm.expect(",
											"        responseEmail,",
											"        \"Значение поля `email` в ответе должно совпадать со значением данного поля в теле запроса\"",
											"    ).to.eql(requestEmail);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{firstUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"email\": \"new@email.ru\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/users/me",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"me"
									]
								}
							},
							"response": []
						},
						{
							"name": "patch_user_me_rollback // First User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"id\": {",
											"            \"type\": \"integer\"",
											"        },",
											"        \"email\": {",
											"            \"type\": \"string\",",
											"            \"format\": \"email\"",
											"        },",
											"        \"is_active\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"is_superuser\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"is_verified\": {",
											"            \"type\": \"boolean\"",
											"        }",
											"    },",
											"    \"required\": [\"id\", \"email\", \"is_active\", \"is_superuser\", \"is_verified\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что корректный запроc зарегистрированного пользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const email = _.get(responseData, \"email\");",
											"    if (email) {",
											"        pm.collectionVariables.set(\"firstUserEmail\", email);",
											"    }",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test(\"Значение поля `email` должно обновиться\", function () {",
											"    const requestEmail = JSON.parse(pm.request.body.raw).email;",
											"    const responseEmail = responseData.email;",
											"    pm.expect(",
											"        responseEmail,",
											"        \"Значение поля `email` в ответе должно совпадать со значением данного поля в теле запроса\"",
											"    ).to.eql(requestEmail);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{firstUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"email\": \"{{firstUserEmail}}\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/users/me",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"me"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "users_details",
					"item": [
						{
							"name": "get_user_details // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"id\": {",
											"            \"type\": \"integer\"",
											"        },",
											"        \"email\": {",
											"            \"type\": \"string\",",
											"            \"format\": \"email\"",
											"        },",
											"        \"is_active\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"is_superuser\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"is_verified\": {",
											"            \"type\": \"boolean\"",
											"        }",
											"    },",
											"    \"required\": [\"id\", \"email\", \"is_active\", \"is_superuser\", \"is_verified\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "GET",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/users/{{secondUserId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"{{secondUserId}}"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "users_patch // Superuser",
					"item": [
						{
							"name": "patch_users_change_email // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"id\": {",
											"            \"type\": \"integer\"",
											"        },",
											"        \"email\": {",
											"            \"type\": \"string\",",
											"            \"format\": \"email\"",
											"        },",
											"        \"is_active\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"is_superuser\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"is_verified\": {",
											"            \"type\": \"boolean\"",
											"        }",
											"    },",
											"    \"required\": [\"id\", \"email\", \"is_active\", \"is_superuser\", \"is_verified\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что корректный запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const email = _.get(responseData, \"email\");",
											"    if (email) {",
											"        pm.collectionVariables.set(\"firstUserEmail\", email);",
											"    }",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test(\"Значение поля `email` должно обновиться\", function () {",
											"    const requestEmail = JSON.parse(pm.request.body.raw).email;",
											"    const responseEmail = responseData.email;",
											"    pm.expect(",
											"        responseEmail,",
											"        \"Значение поля `email` в ответе должно совпадать со значением данного поля в теле запроса\"",
											"    ).to.eql(requestEmail);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"email\": \"new@email.ru\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/users/{{firstUserId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"{{firstUserId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "patch_users_deactivate_user // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"id\": {",
											"            \"type\": \"integer\"",
											"        },",
											"        \"email\": {",
											"            \"type\": \"string\",",
											"            \"format\": \"email\"",
											"        },",
											"        \"is_active\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"is_superuser\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"is_verified\": {",
											"            \"type\": \"boolean\"",
											"        }",
											"    },",
											"    \"required\": [\"id\", \"email\", \"is_active\", \"is_superuser\", \"is_verified\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что корректный запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const email = _.get(responseData, \"email\");",
											"    if (email) {",
											"        pm.collectionVariables.set(\"firstUserEmail\", email);",
											"    }",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test(\"Значение поля `is_active` должно быть `false`\", function () {",
											"    pm.expect(",
											"        responseData.is_active,",
											"        \"Значение поля `is_active` в ответе должно быть `false`\"",
											"    ).to.false;",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"is_active\": false\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/users/{{firstUserId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"{{firstUserId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "patch_users_rollback // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"id\": {",
											"            \"type\": \"integer\"",
											"        },",
											"        \"email\": {",
											"            \"type\": \"string\",",
											"            \"format\": \"email\"",
											"        },",
											"        \"is_active\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"is_superuser\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"is_verified\": {",
											"            \"type\": \"boolean\"",
											"        }",
											"    },",
											"    \"required\": [\"id\", \"email\", \"is_active\", \"is_superuser\", \"is_verified\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что корректный запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const email = _.get(responseData, \"email\");",
											"    if (email) {",
											"        pm.collectionVariables.set(\"firstUserEmail\", email);",
											"    }",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test(\"Значение поля `is_active` должно быть `true`\", function () {",
											"    pm.expect(",
											"        responseData.is_active,",
											"        \"Значение поля `is_active` в ответе должно быть `true`\"",
											"    ).to.true;",
											"});",
											"pm.test(\"Значение поля `email` должно обновиться\", function () {",
											"    const requestEmail = JSON.parse(pm.request.body.raw).email;",
											"    const responseEmail = responseData.email;",
											"    pm.expect(",
											"        responseEmail,",
											"        \"Значение поля `email` в ответе должно совпадать со значением данного поля в теле запроса\"",
											"    ).to.eql(requestEmail);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"email\": \"{{firstUserEmail}}\",\n    \"is_active\": true\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/users/{{firstUserId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"{{firstUserId}}"
									]
								}
							},
							"response": []
						}
					],
					"auth": {
						"type": "bearer",
						"bearer": [
							{
								"key": "token",
								"value": "{{superuserToken}}",
								"type": "string"
							}
						]
					},
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"type": "text/javascript",
								"exec": [
									""
								]
							}
						},
						{
							"listen": "test",
							"script": {
								"type": "text/javascript",
								"exec": [
									""
								]
							}
						}
					]
				},
				{
					"name": "users_bad_requests",
					"item": [
						{
							"name": "get_users_me // No Auth",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 401\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc незарегистрированного пользователя возвращает ответ со статус-кодом 401\"",
											"    ).to.be.eql(\"Unauthorized\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "noauth"
								},
								"method": "GET",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/users/me",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"me"
									]
								}
							},
							"response": []
						},
						{
							"name": "get_user_details_without_permission // First User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 403\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc зарегистрированного пользователя возвращает ответ со статус-кодом 403\"",
											"    ).to.be.eql(\"Forbidden\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{firstUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "GET",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/users/{{secondUserId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"{{secondUserId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "patch_user_me_empty_email // First User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"array\",",
											"            \"items\": {",
											"                \"type\": \"object\",",
											"                \"properties\": {",
											"                    \"loc\": {",
											"                        \"type\": \"array\",",
											"                        \"items\": {",
											"                            \"type\": \"string\"",
											"                        }",
											"                    },",
											"                    \"msg\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                    \"type\": {",
											"                        \"type\": \"string\"",
											"                    }",
											"                },",
											"                \"required\": [\"loc\", \"msg\", \"type\"],",
											"                \"additionalProperties\": false",
											"            }",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 422\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что некорректный запроc зарегистрированного пользователя возвращает ответ со статус-кодом 422\"",
											"    ).to.be.eql(\"Unprocessable Entity\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{firstUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"email\": \"\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/users/me",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"me"
									]
								}
							},
							"response": []
						},
						{
							"name": "patch_user_me // No Auth",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 401\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запрос незарегистрированного пользователя возвращает ответ со статус-кодом 401\"",
											"    ).to.be.eql(\"Unauthorized\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "noauth"
								},
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"email\": \"unauth@email.ru\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/users/me",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"me"
									]
								}
							},
							"response": []
						},
						{
							"name": "get_user_details // No Auth",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 401\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запрос незарегистрированного пользователя возвращает ответ со статус-кодом 401\"",
											"    ).to.be.eql(\"Unauthorized\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "noauth"
								},
								"method": "GET",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/users/{{secondUserId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"{{secondUserId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "get_user_details_without_permission // First User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 403\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запрос пользователя, не являющегося суперюзером, возвращает ответ со статус-кодом 403\"",
											"    ).to.be.eql(\"Forbidden\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{firstUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "GET",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/users/{{secondUserId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"{{secondUserId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "get_user_details_with_bad_user_id // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 404\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запрос суперпользователя возвращает ответ со статус-кодом 404\"",
											"    ).to.be.eql(\"Not Found\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "GET",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/users/999a",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"999a"
									]
								}
							},
							"response": []
						},
						{
							"name": "delete_user // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 405\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запрос суперпользователя возвращает ответ со статус-кодом 405\"",
											"    ).to.be.eql(\"Method Not Allowed\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "DELETE",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/users/{{firstUserId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"{{firstUserId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "patch_users_invalid_email // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"array\",",
											"            \"items\": {",
											"                \"type\": \"object\",",
											"                \"properties\": {",
											"                    \"loc\": {",
											"                        \"type\": \"array\",",
											"                        \"items\": {",
											"                            \"type\": \"string\"",
											"                        }",
											"                    },",
											"                    \"msg\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                    \"type\": {",
											"                        \"type\": \"string\"",
											"                    }",
											"                },",
											"                \"required\": [\"loc\", \"msg\", \"type\"],",
											"                \"additionalProperties\": false",
											"            }",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 422\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что некорректный запроc суперпользователя возвращает ответ со статус-кодом 422\"",
											"    ).to.be.eql(\"Unprocessable Entity\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"email\": \"newemail.ru\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/users/{{firstUserId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"{{firstUserId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "patch_users_without_permission // First User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 403\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запрос пользователя, который не является суперюзером, возвращает ответ со статус-кодом 403\"",
											"    ).to.be.eql(\"Forbidden\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{firstUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"email\": \"new2@email.ru\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/users/{{firstUserId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"{{firstUserId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "patch_users_without_permission // No Auth",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 401\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запрос незарегистрированного пользователя возвращает ответ со статус-кодом 401\"",
											"    ).to.be.eql(\"Unauthorized\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"email\": \"new1@email.ru\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/users/{{firstUserId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"{{firstUserId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "patch_users_with_bad_user_id // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 404\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запрос суперпользователя возвращает ответ со статус-кодом 404\"",
											"    ).to.be.eql(\"Not Found\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"email\": \"newer@email.ru\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/users/999a",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"users",
										"999a"
									]
								}
							},
							"response": []
						}
					]
				}
			]
		},
		{
			"name": "create_get_charity_projects_and_donations",
			"item": [
				{
					"name": "create_donation_without_charity_project",
					"item": [
						{
							"name": "create_first_donation_without_existing_charity_project // Second User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"id\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"full_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"comment\": {",
											"            \"type\": \"string\",",
											"        },",
											"        \"create_date\": {",
											"            \"type\": \"string\",",
											"        }",
											"    },",
											"    \"required\": [\"full_amount\", \"id\", \"comment\", \"create_date\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что корректный запроc зарегистрированного пользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const id = _.get(responseData, \"id\");",
											"    if (id) {",
											"        pm.collectionVariables.set(\"firstDonatId\", id);",
											"    }",
											"    pm.collectionVariables.set(\"secondUserDonationCounter\", 1);",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{secondUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"full_amount\": {{firstProjectAmount}},\n    \"comment\": \"test donation\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/donation/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"donation",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "get_charity_projects // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"array\"",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"});",
											"pm.test(\"Структура ответа должна соответствовать ожидаемой\", function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test(\"В БД не должно быть проектов\", function () {",
											"    pm.expect(",
											"        responseData.length,",
											"        \"Для корректной работы проверок коллекция должна запускаться на чистой базе данных. На момент отправки этого запроса в БД не должно быть проектов\"",
											"    ).to.be.equal(0);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "GET",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/charity_project/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "get_donations // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"array\",",
											"    \"items\": {",
											"        \"properties\": {",
											"            \"comment\": {",
											"                \"type\": [\"string\", \"null\"]",
											"            },",
											"            \"full_amount\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"id\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"invested_amount\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"fully_invested\": {",
											"                \"type\": \"boolean\"",
											"            },",
											"            \"create_date\": {",
											"                \"type\": \"string\",",
											"            },",
											"            \"close_date\": {",
											"                \"type\": [\"string\", \"null\"],",
											"            },",
											"            \"user_id\": {",
											"                \"type\": \"number\"",
											"            }",
											"        },",
											"        \"required\": [\"full_amount\", \"id\", \"comment\", \"create_date\", \"invested_amount\", \"fully_invested\", \"user_id\"],",
											"        \"additionalProperties\": false",
											"    }",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"});",
											"pm.test(\"Структура ответа должна соответствовать ожидаемой\", function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test(",
											"    \"Ответ должен содержать один элемент - поле `invested_amount`; его значением должен быть ноль\",",
											"    function () {",
											"        pm.expect(",
											"            responseData.length,",
											"            \"Этот запрос рассчитан на последовательный запуск коллекции на чистой БД. Для корректной работы на момент отправки этого запроса в БД должно быть только одно пожертвование\"",
											"        ).to.be.equal(1);",
											"        pm.expect(responseData[0]).to.have.property('invested_amount', 0);",
											"    }",
											");",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"protocolProfileBehavior": {
								"disableBodyPruning": true
							},
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "GET",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"full_amount\": {{firstProjectAmount}},\n    \"comment\": \"test donation\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/donation/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"donation",
										""
									]
								}
							},
							"response": []
						}
					],
					"description": "Этот запрос создаёт пожертвование в момент, когда в БД нет проектов.\n\nПроверяется, что пожертвование создаётся успешно и что сумма пожертвования не распределяется.\n\nНа момент выполнения запросов из этой директории в БД не должно быть проектов и пожертвований."
				},
				{
					"name": "create_charity_project_with_not_invested_donation",
					"item": [
						{
							"name": "create_first_project // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"name\": {",
											"            \"type\": \"string\"",
											"        },",
											"        \"description\": {",
											"            \"type\": \"string\"",
											"        },",
											"        \"full_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"id\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"invested_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"fully_invested\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"create_date\": {",
											"            \"type\": \"string\",",
											"        },",
											"        \"close_date\": {",
											"            \"type\": \"string\",",
											"        }",
											"    },",
											"    \"required\": [\"name\", \"description\", \"full_amount\", \"id\", \"invested_amount\", \"fully_invested\", \"create_date\", \"close_date\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что корректный запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const id = _.get(responseData, \"id\");",
											"    if (id) {",
											"        pm.collectionVariables.set(\"firstProjectId\", id);",
											"    }",
											"});",
											"pm.test(\"Структура ответа должна соответствовать ожидаемой\", function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test(\"В проект должны быть направлены нераспределённые пожертвования\", function () {",
											"    pm.expect(",
											"        responseData.fully_invested,",
											"        \"Если в БД есть нераспределённые пожертвования на сумму, достаточную для закрытия нового проекта, создаваемый проект должен быть профинансирован и закрыт\"",
											"    ).to.be.true",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"{{firstProjectName}}\",\n    \"description\": \"First test project\",\n    \"full_amount\": {{firstProjectAmount}}\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										""
									]
								}
							},
							"response": []
						}
					],
					"description": "В БД существует нераспределённое пожертвование. Создается новый проект, сумма которого совпадает с размером данного пожертвования. Проект должен быть профинансирован и закрыт в момент создания."
				},
				{
					"name": "invest_one_donation_to_two_charity_projects",
					"item": [
						{
							"name": "create_second_project // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"name\": {",
											"            \"type\": \"string\"",
											"        },",
											"        \"description\": {",
											"            \"type\": \"string\"",
											"        },",
											"        \"full_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"id\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"invested_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"fully_invested\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"create_date\": {",
											"            \"type\": \"string\",",
											"        },",
											"        \"close_date\": {",
											"            \"type\": [\"string\", \"null\"],",
											"        }",
											"    },",
											"    \"required\": [\"name\", \"description\", \"full_amount\", \"id\", \"invested_amount\", \"fully_invested\", \"create_date\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что корректный запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const id = _.get(responseData, \"id\");",
											"    if (id) {",
											"        pm.collectionVariables.set(\"secondProjectId\", id);",
											"    }",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"Second Project\",\n    \"description\": \"Second test project\",\n    \"full_amount\": {{secondProjectAmount}}\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "create_third_project // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"name\": {",
											"            \"type\": \"string\"",
											"        },",
											"        \"description\": {",
											"            \"type\": \"string\"",
											"        },",
											"        \"full_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"id\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"invested_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"fully_invested\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"create_date\": {",
											"            \"type\": \"string\",",
											"        },",
											"        \"close_date\": {",
											"            \"type\": [\"string\", \"null\"],",
											"        }",
											"    },",
											"    \"required\": [\"name\", \"description\", \"full_amount\", \"id\", \"invested_amount\", \"fully_invested\", \"create_date\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что корректный запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const id = _.get(responseData, \"id\");",
											"    if (id) {",
											"        pm.collectionVariables.set(\"thirdProjectId\", id);",
											"    }",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"Third Project\",\n    \"description\": \"Third test project\",\n    \"full_amount\": {{thirdProjectAmount}}\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "create_second_donation_without_comment_field // Second User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"id\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"full_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"comment\": {",
											"            \"type\": [\"string\", \"null\"],",
											"        },",
											"        \"create_date\": {",
											"            \"type\": \"string\",",
											"        }",
											"    },",
											"    \"required\": [\"full_amount\", \"id\", \"create_date\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что корректный запроc зарегистрированного пользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const id = _.get(responseData, \"id\");",
											"    if (id) {",
											"        pm.collectionVariables.set(\"secondDonatId\", id);",
											"    }",
											"    pm.collectionVariables.set(\"secondUserDonationCounter\", pm.collectionVariables.get(\"secondUserDonationCounter\") + 1);",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{secondUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"full_amount\": {{secondDonationAmount}}\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/donation/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"donation",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "get_donations // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"array\",",
											"    \"items\": {",
											"        \"properties\": {",
											"            \"comment\": {",
											"                \"type\": [\"string\", \"null\"],",
											"            },",
											"            \"full_amount\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"id\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"invested_amount\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"fully_invested\": {",
											"                \"type\": \"boolean\"",
											"            },",
											"            \"create_date\": {",
											"                \"type\": \"string\",",
											"            },",
											"            \"close_date\": {",
											"                \"type\": [\"string\", \"null\"],",
											"            },",
											"            \"user_id\": {",
											"                \"type\": \"number\"",
											"            }",
											"        },",
											"        \"required\": [\"full_amount\", \"id\", \"create_date\", \"invested_amount\", \"fully_invested\", \"user_id\", \"close_date\"],",
											"        \"additionalProperties\": false",
											"    }",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"});",
											"pm.test(\"Структура ответа должна соответствовать ожидаемой\", function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test(",
											"    \"Ответ должен содержать один элемент; значением поля `invested_amount` должен быть ноль\",",
											"    function () {",
											"        pm.expect(",
											"            responseData.length,",
											"            \"Этот запрос рассчитан на последовательный запуск коллекции на чистой БД. Для корректной работы на момент отправки запроса в БД должно быть два пожертвования\"",
											"        ).to.be.equal(2);",
											"        pm.expect(",
											"            responseData[1],",
											"            \"Убедитесь, что пожертвования отсортированы по дате создания\"",
											"        ).to.have.property('id', pm.collectionVariables.get(\"secondDonatId\"));",
											"        pm.expect(",
											"            responseData[1].fully_invested,",
											"            \"Убедитесь, что при наличии незакрытых проектов, суммы которых хватает для полного распределения пожертвования, пожертвование полностью распределяется в момент его создания\"",
											"        ).to.be.true",
											"    }",
											");",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"protocolProfileBehavior": {
								"disableBodyPruning": true
							},
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "GET",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"full_amount\": {{firstProjectAmount}},\n    \"comment\": \"test donation\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/donation/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"donation",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "get_charity_projects // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"array\",",
											"    \"items\": {",
											"        \"properties\": {",
											"            \"name\": {",
											"                \"type\": \"string\"",
											"            },",
											"            \"description\": {",
											"                \"type\": \"string\"",
											"            },",
											"            \"full_amount\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"id\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"invested_amount\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"fully_invested\": {",
											"                \"type\": \"boolean\"",
											"            },",
											"            \"create_date\": {",
											"                \"type\": \"string\",",
											"            },",
											"            \"close_date\": {",
											"                \"type\": [\"string\", \"null\"],",
											"            }",
											"        },",
											"        \"required\": [\"name\", \"description\", \"full_amount\", \"id\", \"invested_amount\", \"fully_invested\", \"create_date\"],",
											"        \"additionalProperties\": false",
											"    }",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"});",
											"pm.test(\"Структура ответа должна соответствовать ожидаемой\", function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test(\"Статусы проектов должны соответствовать ожидаемым\", function () {",
											"    let secondProjectId = parseInt(pm.collectionVariables.get(\"secondProjectId\"), 10);",
											"    let thirdProjectId = parseInt(pm.collectionVariables.get(\"thirdProjectId\"), 10);",
											"    const expectedProjectStatuses = {",
											"        [secondProjectId]: true,",
											"        [thirdProjectId]: false",
											"    };",
											"    responseData.forEach((project) => {",
											"        if (expectedProjectStatuses.hasOwnProperty(project.id)) {",
											"            pm.expect(project.fully_invested).to.eql(expectedProjectStatuses[project.id], ",
											"                \"Проект с `id` ${project.id} в поле `fully_invested` должен иметь значение ${expectedProjectStatuses[project.id]}\");",
											"        }",
											"    });",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "GET",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/charity_project/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										""
									]
								}
							},
							"response": []
						}
					],
					"description": "На момент выполнения запросов из данной директории в БД существует один полностью проинвестированные проект. Нераспределённых пожертвований нет.\n\nСоздаётся два проекта и одно пожертвование. Сумма пожертвования больше суммы одного проекта, но меньше общей суммы двух новых проектов.\n\nПожертвование должно распределиться в момент создания. Первый из созданных проектов должен быть закрыт, во второй распределён остаток средств пожертвования."
				},
				{
					"name": "get_charity_projects_non_superuser",
					"item": [
						{
							"name": "get_charity_projects // Second User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"array\",",
											"    \"items\": {",
											"        \"properties\": {",
											"            \"name\": {",
											"                \"type\": \"string\"",
											"            },",
											"            \"description\": {",
											"                \"type\": \"string\"",
											"            },",
											"            \"full_amount\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"id\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"invested_amount\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"fully_invested\": {",
											"                \"type\": \"boolean\"",
											"            },",
											"            \"create_date\": {",
											"                \"type\": \"string\",",
											"            },",
											"            \"close_date\": {",
											"                \"type\": [\"string\", \"null\"],",
											"            }",
											"        },",
											"        \"required\": [\"name\", \"description\", \"full_amount\", \"id\", \"invested_amount\", \"fully_invested\", \"create_date\"],",
											"        \"additionalProperties\": false",
											"    }",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc зарегистрированного пользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{secondUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "GET",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/charity_project/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "get_charity_projects // No Auth",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"array\",",
											"    \"items\": {",
											"        \"properties\": {",
											"            \"name\": {",
											"                \"type\": \"string\"",
											"            },",
											"            \"description\": {",
											"                \"type\": \"string\"",
											"            },",
											"            \"full_amount\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"id\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"invested_amount\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"fully_invested\": {",
											"                \"type\": \"boolean\"",
											"            },",
											"            \"create_date\": {",
											"                \"type\": \"string\",",
											"            },",
											"            \"close_date\": {",
											"                \"type\": [\"string\", \"null\"],",
											"            }",
											"        },",
											"        \"required\": [\"name\", \"description\", \"full_amount\", \"id\", \"invested_amount\", \"fully_invested\", \"create_date\"],",
											"        \"additionalProperties\": false",
											"    }",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc незарегистрированного пользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "noauth"
								},
								"method": "GET",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/charity_project/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										""
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "create_another_user_donation",
					"item": [
						{
							"name": "create_donation // First User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"id\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"full_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"comment\": {",
											"            \"type\": \"string\",",
											"        },",
											"        \"create_date\": {",
											"            \"type\": \"string\",",
											"        }",
											"    },",
											"    \"required\": [\"full_amount\", \"id\", \"comment\", \"create_date\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что корректный запроc зарегистрированного пользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{firstUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"full_amount\": 100,\n    \"comment\": \"Another user donation\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/donation/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"donation",
										""
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "get_user_donations",
					"item": [
						{
							"name": "get_user_donations // Second User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"array\",",
											"    \"items\": {",
											"        \"properties\": {",
											"            \"id\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"full_amount\": {",
											"                \"type\": \"number\"",
											"            },",
											"            \"comment\": {",
											"                \"type\": [\"string\", \"null\"],",
											"            },",
											"            \"create_date\": {",
											"                \"type\": \"string\",",
											"            }",
											"        },",
											"        \"required\": [\"full_amount\", \"id\", \"create_date\"],",
											"        \"additionalProperties\": false",
											"    }",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc зарегистрированного пользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											"pm.test(",
											"    \"В ответе должны быть только пожертвования пользователя, сделавшего запрос\",",
											"    function () {",
											"        pm.expect(",
											"            responseData.length,",
											"            \"Убедитесь, что ответ содержит только пожертвования пользователя, сделавшего запрос\"",
											"        ).to.be.eql(pm.collectionVariables.get('secondUserDonationCounter'))",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"protocolProfileBehavior": {
								"disableBodyPruning": true
							},
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{secondUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "GET",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"full_amount\": {{firstProjectAmount}},\n    \"comment\": \"test donation\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/donation/my",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"donation",
										"my"
									]
								}
							},
							"response": []
						}
					]
				}
			]
		},
		{
			"name": "update_delete_charity_projects",
			"item": [
				{
					"name": "delete_charity_projects",
					"item": [
						{
							"name": "create_not_invested_charity_project // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"name\": {",
											"            \"type\": \"string\"",
											"        },",
											"        \"description\": {",
											"            \"type\": \"string\"",
											"        },",
											"        \"full_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"id\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"invested_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"fully_invested\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"create_date\": {",
											"            \"type\": \"string\",",
											"        },",
											"        \"close_date\": {",
											"            \"type\": [\"string\", \"null\"],",
											"        }",
											"    },",
											"    \"required\": [\"name\", \"description\", \"full_amount\", \"id\", \"invested_amount\", \"fully_invested\", \"create_date\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что корректный запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const id = _.get(responseData, \"id\");",
											"    if (id) {",
											"        pm.collectionVariables.set(\"notInvestedProjectId\", id);",
											"    }",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"Fourth Project\",\n    \"description\": \"Fourth test project\",\n    \"full_amount\": 100000\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "delete_not_invested_charity_project // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"name\": {",
											"            \"type\": \"string\"",
											"        },",
											"        \"description\": {",
											"            \"type\": \"string\"",
											"        },",
											"        \"full_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"id\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"invested_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"fully_invested\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"create_date\": {",
											"            \"type\": \"string\",",
											"        },",
											"        \"close_date\": {",
											"            \"type\": [\"string\", \"null\"],",
											"        }",
											"    },",
											"    \"required\": [\"name\", \"description\", \"full_amount\", \"id\", \"invested_amount\", \"fully_invested\", \"create_date\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "DELETE",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/charity_project/{{notInvestedProjectId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										"{{notInvestedProjectId}}"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "update_partially_invested_project // Superuser",
					"item": [
						{
							"name": "update_partially_invested_project // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"name\": {",
											"            \"type\": \"string\"",
											"        },",
											"        \"description\": {",
											"            \"type\": \"string\"",
											"        },",
											"        \"full_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"id\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"invested_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"fully_invested\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"create_date\": {",
											"            \"type\": \"string\",",
											"        },",
											"        \"close_date\": {",
											"            \"type\": [\"string\", \"null\"],",
											"        }",
											"    },",
											"    \"required\": [\"name\", \"description\", \"full_amount\", \"id\", \"invested_amount\", \"fully_invested\", \"create_date\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что корректный запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const invested_amount = _.get(responseData, \"invested_amount\")",
											"    if (invested_amount) {",
											"        pm.collectionVariables.set(\"thirdProjectInvestedAmount\", invested_amount);",
											"    }",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"Updated name\",\n    \"description\":\"Updated description\",\n    \"full_amount\": 1400\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/{{thirdProjectId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										"{{thirdProjectId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "update_partially_invested_project_to_close_it // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"name\": {",
											"            \"type\": \"string\"",
											"        },",
											"        \"description\": {",
											"            \"type\": \"string\"",
											"        },",
											"        \"full_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"id\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"invested_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"fully_invested\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"create_date\": {",
											"            \"type\": \"string\",",
											"        },",
											"        \"close_date\": {",
											"            \"type\": \"string\",",
											"        }",
											"    },",
											"    \"required\": [\"name\", \"description\", \"full_amount\", \"id\", \"invested_amount\", \"fully_invested\", \"create_date\", \"close_date\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что корректный запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"Decrease full_ammount to invested_amount\",\n    \"full_amount\": {{thirdProjectInvestedAmount}}\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/{{thirdProjectId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										"{{thirdProjectId}}"
									]
								}
							},
							"response": []
						}
					]
				}
			]
		},
		{
			"name": "bad_requests",
			"item": [
				{
					"name": "delete_charity_projects",
					"item": [
						{
							"name": "create_project // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"name\": {",
											"            \"type\": \"string\"",
											"        },",
											"        \"description\": {",
											"            \"type\": \"string\"",
											"        },",
											"        \"full_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"id\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"invested_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"fully_invested\": {",
											"            \"type\": \"boolean\"",
											"        },",
											"        \"create_date\": {",
											"            \"type\": \"string\",",
											"        },",
											"        \"close_date\": {",
											"            \"type\": [\"string\", \"null\"],",
											"        }",
											"    },",
											"    \"required\": [\"name\", \"description\", \"full_amount\", \"id\", \"invested_amount\", \"fully_invested\", \"create_date\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что корректный запроc суперпользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"    const id = _.get(responseData, \"id\");",
											"    if (id) {",
											"        pm.collectionVariables.set(\"fifthProjectId\", id);",
											"    }",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"Fifth Project\",\n    \"description\": \"Fifth test project\",\n    \"full_amount\": 1000\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "delete_charity_project // Second User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 403\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc зарегистрированного пользователя, не являющегося суперюзером, возвращает ответ со статус-кодом 403\"",
											"    ).to.be.eql(\"Forbidden\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{secondUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "DELETE",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/charity_project/{{fifthProjectId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										"{{fifthProjectId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "delete_charity_project // No Auth",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 401\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc незарегистрированного пользователя возвращает ответ со статус-кодом 401\"",
											"    ).to.be.eql(\"Unauthorized\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "noauth"
								},
								"method": "DELETE",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/charity_project/{{fifthProjectId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										"{{fifthProjectId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "create_donation // Second User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseData = pm.response.json();",
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"id\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"full_amount\": {",
											"            \"type\": \"number\"",
											"        },",
											"        \"comment\": {",
											"            \"type\": \"string\",",
											"        },",
											"        \"create_date\": {",
											"            \"type\": \"string\",",
											"        }",
											"    },",
											"    \"required\": [\"full_amount\", \"id\", \"comment\", \"create_date\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 200\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что корректный запроc зарегистрированного пользователя возвращает ответ со статус-кодом 200\"",
											"    ).to.be.eql(\"OK\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{secondUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"full_amount\": 500,\n    \"comment\": \"Another user donation\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/donation/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"donation",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "delete_partially_invested_charity_project // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 400\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 400\"",
											"    ).to.be.eql(\"Bad Request\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "DELETE",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/charity_project/{{fifthProjectId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										"{{fifthProjectId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "delete_fully_invested_charity_project // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 400\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 400\"",
											"    ).to.be.eql(\"Bad Request\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "DELETE",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/charity_project/{{secondProjectId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										"{{secondProjectId}}"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "update_charity_projects",
					"item": [
						{
							"name": "update_charity_project // No Auth",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 401\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc незарегистрированного пользователя возвращает ответ со статус-кодом 401\"",
											"    ).to.be.eql(\"Unauthorized\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"Updated by anonymous\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/{{fifthProjectId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										"{{fifthProjectId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "update_charity_project // Second User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 403\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc зарегистрированного пользователя, не являющегося суперюзером, возвращает ответ со статус-кодом 403\"",
											"    ).to.be.eql(\"Forbidden\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{secondUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"Updated by regular user\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/{{fifthProjectId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										"{{fifthProjectId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "update_charity_project_with_invalid_name // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"array\",",
											"            \"items\": {",
											"                \"type\": \"object\",",
											"                \"properties\": {",
											"                    \"loc\": {",
											"                        \"type\": \"array\",",
											"                        \"items\": {",
											"                            \"type\": \"string\"",
											"                        }",
											"                    },",
											"                    \"msg\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                    \"type\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                    \"ctx\": {",
											"                        \"type\": \"object\",",
											"                        \"properties\": {",
											"                            \"limit_value\": {",
											"                                \"type\": \"number\"",
											"                            }",
											"                        }",
											"                    }",
											"                },",
											"                \"required\": [\"loc\", \"msg\", \"type\"],",
											"                \"additionalProperties\": false",
											"            }",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 422\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 422\"",
											"    ).to.be.eql(\"Unprocessable Entity\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"Too long name for charity project. The limit should be 100 symbols. Request with long name is invalid\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/{{fifthProjectId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										"{{fifthProjectId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "update_charity_project_with_name_in_use // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\",",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 400\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 400\"",
											"    ).to.be.eql(\"Bad Request\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"{{firstProjectName}}\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/{{fifthProjectId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										"{{fifthProjectId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "update_charity_project_with_invalid_full_amount // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"array\",",
											"            \"items\": {",
											"                \"type\": \"object\",",
											"                \"properties\": {",
											"                    \"loc\": {",
											"                        \"type\": \"array\",",
											"                        \"items\": {",
											"                            \"type\": \"string\"",
											"                        }",
											"                    },",
											"                    \"msg\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                    \"type\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                    \"ctx\": {",
											"                        \"type\": \"object\",",
											"                        \"properties\": {",
											"                            \"limit_value\": {",
											"                                \"type\": \"number\"",
											"                            }",
											"                        }",
											"                    }",
											"                },",
											"                \"required\": [\"loc\", \"msg\", \"type\"],",
											"                \"additionalProperties\": false",
											"            }",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 422\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 422\"",
											"    ).to.be.eql(\"Unprocessable Entity\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"full_amount\": 0\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/{{fifthProjectId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										"{{fifthProjectId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "update_charity_project_full_amount_less_then_already_invested // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 400\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 400\"",
											"    ).to.be.eql(\"Bad Request\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"full_amount\": 10\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/{{fifthProjectId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										"{{fifthProjectId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "update_charity_project_with_put_request // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 405\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 405\"",
											"    ).to.be.eql(\"Method Not Allowed\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "PUT",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"full_amount\": 50000\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/{{fifthProjectId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										"{{fifthProjectId}}"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "create_charity_projects",
					"item": [
						{
							"name": "create_charity_project_with_invalid_full_amount // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"array\",",
											"            \"items\": {",
											"                \"type\": \"object\",",
											"                \"properties\": {",
											"                    \"loc\": {",
											"                        \"type\": \"array\",",
											"                        \"items\": {",
											"                            \"type\": \"string\"",
											"                        }",
											"                    },",
											"                    \"msg\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                    \"type\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                    \"ctx\": {",
											"                        \"type\": \"object\",",
											"                        \"properties\": {",
											"                            \"limit_value\": {",
											"                                \"type\": \"number\"",
											"                            }",
											"                        }",
											"                    }",
											"                },",
											"                \"required\": [\"loc\", \"msg\", \"type\", \"ctx\"],",
											"                \"additionalProperties\": false",
											"            }",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 422\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 422\"",
											"    ).to.be.eql(\"Unprocessable Entity\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"Invalid Project\",\n    \"description\": \"Invalid test project\",\n    \"full_amount\": 0\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "create_charity_project_with_invalid_name // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"array\",",
											"            \"items\": {",
											"                \"type\": \"object\",",
											"                \"properties\": {",
											"                    \"loc\": {",
											"                        \"type\": \"array\",",
											"                        \"items\": {",
											"                            \"type\": \"string\"",
											"                        }",
											"                    },",
											"                    \"msg\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                    \"type\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                    \"ctx\": {",
											"                        \"type\": \"object\",",
											"                        \"properties\": {",
											"                            \"limit_value\": {",
											"                                \"type\": \"number\"",
											"                            }",
											"                        }",
											"                    }",
											"                },",
											"                \"required\": [\"loc\", \"msg\", \"type\", \"ctx\"],",
											"                \"additionalProperties\": false",
											"            }",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 422\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 422\"",
											"    ).to.be.eql(\"Unprocessable Entity\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"Too long name for charity project. The limit should be 100 symbols.Request with long name is invalid.\",\n    \"description\": \"Invalid name test project\",\n    \"full_amount\": 1000\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "create_charity_project_without_name // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"array\",",
											"            \"items\": {",
											"                \"type\": \"object\",",
											"                \"properties\": {",
											"                    \"loc\": {",
											"                        \"type\": \"array\",",
											"                        \"items\": {",
											"                            \"type\": \"string\"",
											"                        }",
											"                    },",
											"                    \"msg\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                    \"type\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                },",
											"                \"required\": [\"loc\", \"msg\", \"type\"],",
											"                \"additionalProperties\": false",
											"            }",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 422\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 422\"",
											"    ).to.be.eql(\"Unprocessable Entity\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"description\": \"Project without name\",\n    \"full_amount\": 1000\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "create_charity_project_without_description // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"array\",",
											"            \"items\": {",
											"                \"type\": \"object\",",
											"                \"properties\": {",
											"                    \"loc\": {",
											"                        \"type\": \"array\",",
											"                        \"items\": {",
											"                            \"type\": \"string\"",
											"                        }",
											"                    },",
											"                    \"msg\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                    \"type\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                },",
											"                \"required\": [\"loc\", \"msg\", \"type\"],",
											"                \"additionalProperties\": false",
											"            }",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 422\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 422\"",
											"    ).to.be.eql(\"Unprocessable Entity\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"No description\",\n    \"full_amount\": 1000\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "create_charity_project_without_full_amount // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"array\",",
											"            \"items\": {",
											"                \"type\": \"object\",",
											"                \"properties\": {",
											"                    \"loc\": {",
											"                        \"type\": \"array\",",
											"                        \"items\": {",
											"                            \"type\": \"string\"",
											"                        }",
											"                    },",
											"                    \"msg\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                    \"type\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                },",
											"                \"required\": [\"loc\", \"msg\", \"type\"],",
											"                \"additionalProperties\": false",
											"            }",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 422\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 422\"",
											"    ).to.be.eql(\"Unprocessable Entity\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"No full amount\",\n    \"description\": \"No full amount\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "create_charity_project // Second User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 403\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc зарегистрированного пользователя, не являющегося суперюзером, возвращает ответ со статус-кодом 403\"",
											"    ).to.be.eql(\"Forbidden\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{secondUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"Forbiddeb\",\n    \"description\": \"Regular user can not create projects\",\n    \"full_amount\": 1000\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "create_charity_project // No Auth",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 401\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc незарегистрированного пользователя возвращает ответ со статус-кодом 401\"",
											"    ).to.be.eql(\"Unauthorized\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "noauth"
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"name\": \"Unauthorized\",\n    \"description\": \"Unauthorized user can not create projects\",\n    \"full_amount\": 1000\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/charity_project/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"charity_project",
										""
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "create_donations",
					"item": [
						{
							"name": "create_donation_with_zero_amount // Second User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"array\",",
											"            \"items\": {",
											"                \"type\": \"object\",",
											"                \"properties\": {",
											"                    \"loc\": {",
											"                        \"type\": \"array\",",
											"                        \"items\": {",
											"                            \"type\": \"string\"",
											"                        }",
											"                    },",
											"                    \"msg\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                    \"type\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                    \"ctx\": {",
											"                        \"type\": \"object\",",
											"                        \"properties\": {",
											"                            \"limit_value\": {",
											"                                \"type\": \"number\"",
											"                            }",
											"                        }",
											"                    }",
											"                },",
											"                \"required\": [\"loc\", \"msg\", \"type\", \"ctx\"],",
											"                \"additionalProperties\": false",
											"            }",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 422\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc зарегистрированного пользователя возвращает ответ со статус-кодом 422\"",
											"    ).to.be.eql(\"Unprocessable Entity\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{secondUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"full_amount\": 0,\n    \"comment\": \"Zero donation\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/donation/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"donation",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "create_donation_without_full_amount // Second User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"array\",",
											"            \"items\": {",
											"                \"type\": \"object\",",
											"                \"properties\": {",
											"                    \"loc\": {",
											"                        \"type\": \"array\",",
											"                        \"items\": {",
											"                            \"type\": \"string\"",
											"                        }",
											"                    },",
											"                    \"msg\": {",
											"                        \"type\": \"string\"",
											"                    },",
											"                    \"type\": {",
											"                        \"type\": \"string\"",
											"                    }",
											"                },",
											"                \"required\": [\"loc\", \"msg\", \"type\"],",
											"                \"additionalProperties\": false",
											"            }",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 422\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc зарегистрированного пользователя возвращает ответ со статус-кодом 422\"",
											"    ).to.be.eql(\"Unprocessable Entity\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{secondUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"comment\": \"No amount donation\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/donation/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"donation",
										""
									]
								}
							},
							"response": []
						},
						{
							"name": "create_donation // No Auth",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 401\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc незарегистрированного пользователя возвращает ответ со статус-кодом 401\"",
											"    ).to.be.eql(\"Unauthorized\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "noauth"
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"full_amount\": 500,\n    \"comment\": \"Unauthorized user donation\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/donation/",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"donation",
										""
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "update_donations",
					"item": [
						{
							"name": "patch_donation // Second User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 404\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc зарегистрированного пользователя возвращает ответ со статус-кодом 404\"",
											"    ).to.be.eql(\"Not Found\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{secondUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "PATCH",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"comment\": \"Change my mind\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/donation/{{firstDonatId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"donation",
										"{{firstDonatId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "put_donation // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 404\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 404\"",
											"    ).to.be.eql(\"Not Found\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "PUT",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\n    \"comment\": \"Change my mind\"\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "{{baseURL}}/donation/{{firstDonatId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"donation",
										"{{firstDonatId}}"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "delete_donations",
					"item": [
						{
							"name": "delete_donation // Superuser",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 404\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc суперпользователя возвращает ответ со статус-кодом 404\"",
											"    ).to.be.eql(\"Not Found\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{superuserToken}}",
											"type": "string"
										}
									]
								},
								"method": "DELETE",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/donation/{{firstDonatId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"donation",
										"{{firstDonatId}}"
									]
								}
							},
							"response": []
						},
						{
							"name": "delete_donation // Second User",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseSchema = {",
											"    \"type\": \"object\",",
											"    \"properties\": {",
											"        \"detail\": {",
											"            \"type\": \"string\"",
											"        }",
											"    },",
											"    \"required\": [\"detail\"],",
											"    \"additionalProperties\": false",
											"};",
											"",
											"pm.test(\"Статус-код ответа должен быть 404\", function () {",
											"    pm.expect(",
											"        pm.response.status,",
											"        \"Убедитесь, что запроc пользователя, не являющегося суперюзером, возвращает ответ со статус-кодом 404\"",
											"    ).to.be.eql(\"Not Found\");",
											"});",
											"pm.test('Структура ответа должна соответствовать ожидаемой', function () {",
											"    pm.response.to.have.jsonSchema(responseSchema);",
											"});",
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{secondUserToken}}",
											"type": "string"
										}
									]
								},
								"method": "DELETE",
								"header": [],
								"url": {
									"raw": "{{baseURL}}/donation/{{firstDonatId}}",
									"host": [
										"{{baseURL}}"
									],
									"path": [
										"donation",
										"{{firstDonatId}}"
									]
								}
							},
							"response": []
						}
					]
				}
			]
		}
	],
	"event": [
		{
			"listen": "prerequest",
			"script": {
				"type": "text/javascript",
				"exec": [
					""
				]
			}
		},
		{
			"listen": "test",
			"script": {
				"type": "text/javascript",
				"exec": [
					""
				]
			}
		}
	],
	"variable": [
		{
			"key": "baseURL",
			"value": "http://127.0.0.1:8000",
			"type": "string"
		},
		{
			"key": "firstUserEmail",
			"value": "first@user.ru",
			"type": "string"
		},
		{
			"key": "firstUserPassword",
			"value": "qdrhuk194",
			"type": "string"
		},
		{
			"key": "secondUserEmail",
			"value": "second@user.ru",
			"type": "string"
		},
		{
			"key": "secondUserPassword",
			"value": "sdciorpe367",
			"type": "string"
		},
		{
			"key": "superuserEmail",
			"value": "root@admin.ru",
			"type": "string"
		},
		{
			"key": "superuserPassword",
			"value": "root",
			"type": "string"
		},
		{
			"key": "firstProjectAmount",
			"value": "1000",
			"type": "string"
		},
		{
			"key": "firstProjectName",
			"value": "First Project",
			"type": "string"
		},
		{
			"key": "secondProjectAmount",
			"value": "2000",
			"type": "string"
		},
		{
			"key": "thirdProjectAmount",
			"value": "1500",
			"type": "string"
		},
		{
			"key": "secondDonationAmount",
			"value": "2500",
			"type": "string"
		}
	]
}